#include "session.hpp"
#include "matcher.hpp"
#include "MYSQL_api.hpp"
#include "Online_manger.hpp"

#define HTTPROOT "./wwwroot/webroot"

class gobang_server
{
private:
    // 静态资源请求
    void file_handler(wsserver_t::connection_ptr &conn)
    {
        string body;
        // wsserver_t::connection_ptr conn = _wst.get_con_from_hdl(conn);
        websocketpp::http::parser::request req = conn->get_request();
        string method = req.get_method();
        string uri = req.get_uri();
        if (uri[uri.size() - 1] == '/')
        {
            uri += "login.html";
        }
        string pathname = _web_root + uri;
        //
        // cout << "路径：" << pathname << endl;
        bool ret = File_Util::read(pathname, body);
        if (!ret)
        {
            body += "<html>";
            body += "<head>";
            body += "<meta charset='UTF-8'/>";
            body += "</head>";
            body += "<body>";
            body += "<h1> Not Found </h1>";
            body += "</body>";
            conn->set_status(websocketpp::http::status_code::not_found);
            conn->set_body(body);
            return;
        }
        conn->set_status(websocketpp::http::status_code::ok);
        conn->set_body(body);
    }

    void http_resp(bool result, wsserver_t::connection_ptr &conn, websocketpp::http::status_code::value status, const string &reason)
    {
        string Rtext;
        Json::Value RJson;
        RJson["result"] = result;
        RJson["reason"] = reason;
        Json_api::serialize(RJson, Rtext);
        conn->set_body(Rtext);
        conn->append_header("Content-Type", "application/json");
        conn->set_status(status);
        return;
    }
    // 处理注册逻辑
    void reg(wsserver_t::connection_ptr &conn)
    {
        // 1、获取正文
        websocketpp::http::parser::request req = conn->get_request();
        //
        string body = req.get_body();
        Json::Value text;
        Json_api::unserialize(text, body);
        // 2、对数据库进行用户更新
        string rbody; // 返回给客户端的文本内容
        cout << "获取正文：" << body << endl;
        if (text["username"].isNull() || text["password"].isNull())
        {
            // 此时注册信息中编号或者密码为空进行返回并报错
            http_resp(true, conn, websocketpp::http::status_code::ok, "请按照正确的格式输入账号密码");
            DLOG("注册用户账号密码格式错误！");
        }
        bool ret = _ut.Insert(text);
        // 3、成功返回200
        if (ret)
        {
            DLOG("成功注册用户 %s", text["username"].asCString());
            http_resp(true, conn, websocketpp::http::status_code::ok, "用户注册成功");
            return;
        }
        // 4、失败返回400
        http_resp(false, conn, websocketpp::http::status_code::bad_request, "用户注册失败");
        DLOG("注册用户 %s失败！！！", text["username"].asCString());
        return;
    }

    // 处理登录逻辑
    void login(wsserver_t::connection_ptr &conn)
    {
        // 1、获取正文
        websocketpp::http::parser::request req = conn->get_request();
        //
        string body = req.get_body();
        Json::Value text, UserInfo; // 用户信息
        Json_api::unserialize(text, body);
        // 2、检查前端上传数据是否完整
        string rbody; // 返回给客户端的文本内容
        if (text["username"].isNull() || text["password"].isNull())
        {
            // 此时注册信息中编号或者密码为空进行返回并报错
            http_resp(true, conn, websocketpp::http::status_code::ok, "请按照正确的格式输入账号密码");
            DLOG("注册用户账号密码格式错误！");
        }
        // 3、进行登录逻辑判断
        bool ret = _ut.Login_user(text);
        if (ret)
        {
            _ut.Select_user(text["username"].asCString(), UserInfo);
            // 为新登录用户创建对应的session
            session_ptr sp = _sm.create_session(UserInfo["id"].asInt(), ss_status::LOGIN);
            if (sp == nullptr)
            {
                DLOG("%d 用户创建session会话失败！", UserInfo["id"].asInt());
                return;
            }
            _sm.set_session_expir_time(sp->get_ssid(), TIME_TEMP); // 创建session并设置为临时
            // 将session设置进cookie中，然后再一同返回给前端
            std::string cookie_ssid = "SSID=" + std::to_string(sp->get_ssid());
            conn->append_header("Set-Cookie", cookie_ssid);
            return http_resp(true, conn, websocketpp::http::status_code::ok, "登录成功！");
        }
        // 查询用户失败时：
        //  4、失败返回400
        http_resp(false, conn, websocketpp::http::status_code::bad_request, "用户登录失败，请检查账号及密码是否正确");
        DLOG("注册用户 %s失败！！！", text["username"].asCString());
        return;
    }

    // 通过信息获取cookie中的信息
    bool get_cookie_value(const string &cookie_str, const string &Type, string &tmp_Value)
    {
        // Cookie: SSID=XXX; path=/;
        // 1. 以 ; 作为间隔，对字符串进⾏分割，得到各个单个的cookie信息
        string sep = "; ";
        vector<string> cookie_arr;
        String_Util::StrSub(cookie_str, sep, cookie_arr);
        for (auto e : cookie_arr)
        {
            vector<string> arr;
            String_Util::StrSub(e, "=", arr);
            if (arr.size() != 2)
                continue;
            if (arr[0] == Type)
            {
                tmp_Value = arr[1];
                return true;
            }
        }
        return false;
    }

    // 处理用户信息逻辑
    void info(wsserver_t::connection_ptr &conn)
    {
        Json::Value Uinfo; // 待返回的用户信息
        // 从cookie中获取ssid值
        string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            return http_resp(false, conn, websocketpp::http::status_code::bad_request, "找不到用户cookie信息，请重新登录");
        }
        // 从cookie信息中获取ssid值
        string ssid;
        bool check = gobang_server::get_cookie_value(cookie_str, "SSID", ssid);
        if (!check)
        {
            return http_resp(false, conn, websocketpp::http::status_code::bad_request, "找不到用户ssid信息，请重新登录");
        }
        // 通过ssid信息查找到用户的uid值
        session_ptr tmp_s = _sm.get_session_from_ssid(stoi(ssid));
        // 通过uid值去数据库中找到用户的信息
        bool ret = _ut.Select_id(tmp_s->get_user(), Uinfo);
        if (!ret)
        {
            return http_resp(false, conn, websocketpp::http::status_code::bad_request, "无该用户记录！！！");
        }
        // 找到了用户信息，将对应Json数据进行序列化然后再进行返回
        string body; // 序列化后待返回的字符串
        Json_api::serialize(Uinfo, body);
        //
        // cout << "序列化后body: " << body << endl;
        conn->set_body(body);
        conn->append_header("Content-Type", "application/json");
        conn->set_status(websocketpp::http::status_code::ok);
        _sm.set_session_expir_time(stoi(ssid), TIME_TEMP);
        return;
    }

    // 连接大厅时进入长连接时的任务。
    void wsopen_game_hall(wsserver_t::connection_ptr &conn)
    {
        Json::Value text;
        string body;
        // 1、获取当前登录用户的session
        string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            // return http_resp(false, conn, websocketpp::http::status_code::bad_request, "找不到用户cookie信息，请重新登录");
            text["optype"] = "hall_ready";
            text["reason"] = "找不到用户cookie信息，请重新登录!";
            text["result"] = false;
            Json_api::serialize(text, body);
            conn->send(body);
        }
        // 从cookie信息中获取ssid值
        string ssid;
        bool check = gobang_server::get_cookie_value(cookie_str, "SSID", ssid);
        if (!check)
        {
            text["optype"] = "hall_ready";
            text["reason"] = "找不到用户ssid信息，请重新登录!";
            text["result"] = false;
            Json_api::serialize(text, body);
            conn->send(body);
            return;
        }
        // 2、根据session判断该用户是否在其他地方登录。
        if (_om.in_game_hall(_sm.get_session_from_ssid(stoi(ssid))->get_user()) || _om.in_room_hall(_sm.get_session_from_ssid(stoi(ssid))->get_user()))
        {
            text["optype"] = "hall_ready";
            text["reason"] = "该用户已在其它地方登录！";
            text["result"] = false;
            Json_api::serialize(text, body);
            conn->send(body);
            return;
        }
        text["optype"] = "hall_ready";
        text["reason"] = ssid + " 号连接建立成功";
        text["result"] = true;
        Json_api::serialize(text, body);
        conn->send(body);
        // 将该用户添加至游戏大厅中
        _om.enter_game_hall(_sm.get_session_from_ssid(stoi(ssid))->get_user(), conn);
        // 将当前session设置为永久存在
        _sm.set_session_expir_time(stoi(ssid), TIME_LONG);
    }

    // 连接游戏房间时进入长连接任务。
    void wsopen_game_room(wsserver_t::connection_ptr &conn)
    {
        // 1、获取当前用户的session值
        Json::Value text;
        string body;
        // 1、获取当前登录用户的session
        string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            // return http_resp(false, conn, websocketpp::http::status_code::bad_request, "找不到用户cookie信息，请重新登录");
            text["optype"] = "room_ready";
            text["reason"] = "找不到用户cookie信息，请重新登录!";
            text["result"] = false;
            Json_api::serialize(text, body);
            conn->send(body);
        }
        // 从cookie信息中获取ssid值
        string ssid;
        bool check = gobang_server::get_cookie_value(cookie_str, "SSID", ssid);
        if (!check)
        {
            text["optype"] = "room_ready";
            text["reason"] = "找不到用户ssid信息，请重新登录!";
            text["result"] = false;
            Json_api::serialize(text, body);
            conn->send(body);
            return;
        }
        // 2、判断用户是否已经在线（其实前面就已经有判断过了，所以这里不做判断）
        // 3、判断对应游戏房间是否已经被建立
        room_ptr rptr = _rm.get_room_from_uid(_sm.get_session_from_ssid(stoi(ssid))->get_user());
        if (rptr.get() == nullptr)
        {
           
            text["optype"] = "room_ready";
            text["reason"] = "房间未实现建立";
            text["result"] = false;
            Json_api::serialize(text, body);
            conn->send(body);
            return;
        }

        text["optype"] = "room_ready";
        text["reason"] = ssid + " 号进入房间成功";
        text["result"] = true;
        text["room_id"] = rptr->get_room_id();
        text["uid"] = _sm.get_session_from_ssid(stoi(ssid))->get_user();
        text["white_id"] = rptr->get_white_user();
        text["black_id"] = rptr->get_black_user();
        Json_api::serialize(text, body);
        conn->send(body);
        //
        // cout << "发送数据3: " << text << endl;
        // 因为前面用户从大厅到游戏房间默认与大厅断开长连接，session值被设置为临时，所以这里需要重新对session设为永久
        //  将该用户添加至游戏房间中
        _om.enter_room_hall(_sm.get_session_from_ssid(stoi(ssid))->get_user(), conn);
        // 将当前session设置为永久存在
        _sm.set_session_expir_time(stoi(ssid), TIME_LONG);
    }

    // 与游戏大厅断开连接时请求
    void wsclose_game_hall(wsserver_t::connection_ptr &conn)
    {
        Json::Value text;
        string body;
        // 1、获取当前登录用户的session
        string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            // return http_resp(false, conn, websocketpp::http::status_code::bad_request, "找不到用户cookie信息，请重新登录");
            text["optype"] = "hall_ready";
            text["reason"] = "找不到用户cookie信息，请重新登录!";
            text["result"] = false;
            Json_api::serialize(text, body);
            conn->send(body);
        }
        // 从cookie信息中获取ssid值
        string ssid;
        bool check = gobang_server::get_cookie_value(cookie_str, "SSID", ssid);
        if (!check)
        {
            text["optype"] = "hall_ready";
            text["reason"] = "找不到用户ssid信息，请重新登录!";
            text["result"] = false;
            Json_api::serialize(text, body);
            conn->send(body);
            return;
        }
        text["optype"] = "hall_ready";
        text["reason"] = ssid + " 退出大厅长连接";
        text["result"] = true;
        Json_api::serialize(text, body);
        conn->send(body);
        // 将用户从大厅管理中退出
        _om.exit_game_hall(_sm.get_session_from_ssid(stoi(ssid))->get_user());
        // 将该用户session时长设置为临时
        _sm.set_session_expir_time(stoi(ssid), TIME_TEMP);
    }

    void wsclose_game_room(wsserver_t::connection_ptr &conn)
    {
        Json::Value text;
        string body;
        // 1、获取当前登录用户的session
        string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            // return http_resp(false, conn, websocketpp::http::status_code::bad_request, "找不到用户cookie信息，请重新登录");
            text["optype"] = "room_ready";
            text["reason"] = "找不到用户cookie信息，请重新登录!";
            text["result"] = false;
            Json_api::serialize(text, body);
            conn->send(body);
        }
        // 从cookie信息中获取ssid值
        string ssid;
        bool check = gobang_server::get_cookie_value(cookie_str, "SSID", ssid);
        if (!check)
        {
            text["optype"] = "room_ready";
            text["reason"] = "找不到用户ssid信息，请重新登录!";
            text["result"] = false;
            Json_api::serialize(text, body);
            conn->send(body);
            return;
        }
        text["optype"] = "room_ready";
        text["reason"] = ssid + " 退出游戏房间长连接";
        text["result"] = true;
        Json_api::serialize(text, body);
        conn->send(body);
        DLOG("%d 用户退出房间", _sm.get_session_from_ssid(stoi(ssid))->get_user());
        // 将用户从房间管理中移除
        _om.exit_room_hall(_sm.get_session_from_ssid(stoi(ssid))->get_user());
        // 将用户session从永久改为临时
        _sm.set_session_expir_time(stoi(ssid), TIME_TEMP);
        // 将该玩家从游戏房间中删除掉
        _rm.remove_user(_sm.get_session_from_ssid(stoi(ssid))->get_user());
    }

    // websocketpp长链接成功的回调函数
    void Open_func(websocketpp::connection_hdl hdl)
    {
        // 获取与网页的通信连接
        wsserver_t::connection_ptr conn = _wst.get_con_from_hdl(hdl);
        // 获取与网页通信内容。
        websocketpp::http::parser::request req = conn->get_request();
        string uri = req.get_uri();
        // 与大厅长连接的函数任务
        // cout << "获取到uri为: " << uri << endl;
        if (uri == "/hall")
            return wsopen_game_hall(conn);
        else if (uri == "/room")
            return wsopen_game_room(conn);
    }

    // websocketpp链接关闭回调函数
    void Close_func(websocketpp::connection_hdl hdl)
    {
        // 获取与网页的通信连接
        wsserver_t::connection_ptr conn = _wst.get_con_from_hdl(hdl);
        // 获取与网页通信内容。
        websocketpp::http::parser::request req = conn->get_request();
        string uri = req.get_uri();
        // 与大厅断开连接的函数任务
        if (uri == "/hall")
        {
            return wsclose_game_hall(conn);
        }
        else if (uri == "/room")
        {
            return wsclose_game_room(conn);
        }
    }

    // 大厅消息处理函数
    // 主要有开始匹配，取消匹配
    void msg_game_hall(wsserver_t::connection_ptr &conn, wsserver_t::message_ptr msg)
    {
        // 1、通过cookie获取session
        string cookie_str = conn->get_request_header("Cookie");
        string ssid;
        gobang_server::get_cookie_value(cookie_str, "SSID", ssid);
        // 2、通过session获取用户uid。
        int uid = _sm.get_session_from_ssid(stoi(ssid))->get_user();
        // 3、获取前端返回的信息。
        string req_body = msg->get_payload();
        Json::Value req_json, json_text;
        bool ret = Json_api::unserialize(req_json, req_body);
        if (!ret)
        {
            json_text["result"] = false;
            json_text["reason"] = "信息解析失败";
            string body;
            Json_api::serialize(json_text, body);
            conn->send(body);
            return;
        }
        // 如果是开始匹配：
        // cout << "前端发送数据：‘" << req_json["optype"].asString() << "’" << endl;
        if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_start")
        {
            // 将其加入匹配队列中
            cout << "即将加入匹配队列中" << endl;
            _mt.add(uid);
            json_text["result"] = true;
            json_text["optype"] = "match_start";
            string body;
            Json_api::serialize(json_text, body);
            conn->send(body);
            return;
        }
        // 如果是取消匹配：
        if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_stop")
        {
            // 将其从匹配队列中删除
            cout << "即将从匹配队列中删除" << endl;
            _mt.sub(uid);
            json_text["result"] = true;
            json_text["optype"] = "match_stop";
            string body;
            Json_api::serialize(json_text, body);
            conn->send(body);
            return;
        }
    }

    // 游戏房间消息处理函数
    void msg_game_room(wsserver_t::connection_ptr &conn, wsserver_t::message_ptr msg)
    {
        // 1、通过cookie获取session
        string cookie_str = conn->get_request_header("Cookie");
        string ssid;
        Json::Value rtext, req;
        gobang_server::get_cookie_value(cookie_str, "SSID", ssid);
        // 2、通过session获取用户uid。
        int uid = _sm.get_session_from_ssid(stoi(ssid))->get_user();
        // 3、通过uid找到对应的房间
        room_ptr rptr = _rm.get_room_from_uid(uid);
        if(rptr.get() == nullptr)
        {
            string body;
            rtext["optype"] = "unknow";
            rtext["reason"] = "未找到对应房间信息";
            rtext["result"] = false;
            DLOG("未找到用户 %d 对应的房间", uid);
            Json_api::serialize(rtext, body);
            conn->send(body);
            return;
        }
        string tmp = msg->get_payload();
        Json_api::unserialize(req, tmp);
        //DLOG("%d 房间收到消息，准备处理", rptr->get_room_id());
        rptr->handle_request(req);
    }

    // websocketpp消息回调处理函数
    void Message_func(websocketpp::connection_hdl hdl, wsserver_t::message_ptr msg)
    {
        // 获取与网页的通信连接
        wsserver_t::connection_ptr conn = _wst.get_con_from_hdl(hdl);
        // 获取与网页通信内容。
        websocketpp::http::parser::request req = conn->get_request();
        string uri = req.get_uri();
        // 与大厅断开连接的函数任务
        if (uri == "/hall")
        {
            return msg_game_hall(conn, msg);
        }
        else if (uri == "/room")
        {
            return msg_game_room(conn, msg);
        }
    }

    // 响应http请求时任务处理函数
    void http_func(websocketpp::connection_hdl hdl)
    {
        string body;
        wsserver_t::connection_ptr conn = _wst.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        string method = req.get_method();
        string uri = req.get_uri();
        //
        // cout << "method: " << method << " uri: " << uri << endl;
        if (method == "POST" && uri == "/reg")
        {
            return reg(conn);
        }
        else if (method == "POST" && uri == "/login")
        {
            return login(conn);
        }
        else if (method == "GET" && uri == "/info")
        {
            return info(conn);
        }
        else
        {
            return file_handler(conn);
        }
    }

public:
    gobang_server(const char *user, const char *passwd, const char *host, const char *db,
                  unsigned int port, const char *unix_socket = NULL,
                  unsigned long clientflag = 0, const char *chara = "utf8",
                  const string &http_root = HTTPROOT)
        : _web_root(HTTPROOT), _ut(user, passwd, host, db, port, unix_socket, clientflag, chara), _wst(), _sm(&_wst), _rm(&_ut, &_om), _mt(&_rm, &_ut, &_om)
    {
        // 2.设置websocketpp的日志等级
        _wst.set_access_channels(websocketpp::log::alevel::none); // 禁止生成日志
        // 3.初始化asio框架，设置地址重用，保证服务器掉后立马能重复使用之前端口号恢复
        _wst.init_asio();
        _wst.set_reuse_addr(true);
        _wst.set_open_handler(bind(&gobang_server::Open_func, this, placeholders::_1));
        _wst.set_close_handler(bind(&gobang_server::Close_func, this, placeholders::_1));
        _wst.set_message_handler(bind(&gobang_server::Message_func, this, placeholders::_1, placeholders::_2));
        _wst.set_http_handler(bind(&gobang_server::http_func, this, placeholders::_1));
    }
    ~gobang_server()
    {
    }
    // 启动服务器
    void start(int port)
    {
        // 5.打开监听端口号
        _wst.listen(port);
        // 6.开始接收tcp连接请求
        _wst.start_accept();
        // 7.开始允许服务器
        _wst.run();
    }

private:
    online_manger _om;     // 在线用户管理函数接口
    Mysql_api _ut;         // 用户信息表接口函数
    matcher _mt;           // 匹配管理类
    wsserver_t _wst;       // websocketpp对象
    std::string _web_root; // 模拟静态资源根目录，
    room_manager _rm;
    session_manager _sm;
};